{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算熵\n",
    "def calcShannonEnt(dataSet):\n",
    "    numEntries = len(dataSet)\n",
    "    labelCounts = {}\n",
    "    for featVec in dataSet:\n",
    "        currentLabel = featVec[-1]\n",
    "        if currentLabel not in labelCounts.keys():\n",
    "            labelCounts[currentLabel] = 0\n",
    "        labelCounts[currentLabel] += 1\n",
    "    shannonEnt = 0.0\n",
    "    for key in labelCounts:\n",
    "        prob = float(labelCounts[key]) / numEntries\n",
    "        shannonEnt = shannonEnt - prob * log(prob, 2)\n",
    "    return shannonEnt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createDataSet():\n",
    "    dataSet = [[1, 1, 'yes'],\n",
    "              [1, 1, 'yes'],\n",
    "              [1, 0, 'no'],\n",
    "              [0, 1, 'no'],\n",
    "              [0, 1, 'no']]\n",
    "    labels = ['no surfacing', 'flippers']\n",
    "    return dataSet, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "myDat, labels = createDataSet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "myDat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "calcShannonEnt(myDat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 熵越高，则混合的数据也越多，我们可以在数据集中添加更多的分类，观察熵是如何变化的。\n",
    "# 这里我们增加第三个名为'maybe'的分类，测试熵的变化：\n",
    "myDat[0][-1] = 'maybe'\n",
    "myDat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "calcShannonEnt(myDat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 划分数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# append 与 extend 区别\n",
    "a = [1, 2, 3]\n",
    "b = [4, 5, 6]\n",
    "a.append(b)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "a.extend(b)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 划分数据集：以特征axis进行划分，返回划分后的结果集\n",
    "# 参数：待划分的数据集、划分数据集的特征、特征的返回值\n",
    "def splitDataSet(dataSet, axis, value):\n",
    "    retDataSet = []\n",
    "    for featVec in dataSet:\n",
    "        if featVec[axis] == value:\n",
    "            reduceFeatVec = featVec[:axis]\n",
    "            reduceFeatVec.extend(featVec[axis+1:])\n",
    "            retDataSet.append(reduceFeatVec)\n",
    "    return retDataSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "myDat, labels = createDataSet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myDat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 'yes'], [1, 'yes'], [0, 'no']]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "splitDataSet(myDat, 0, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 'no'], [1, 'no']]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "splitDataSet(myDat, 0, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 寻找最好的特征划分，返回特征值\n",
    "# 在 函 数 中 调 用 的 数 据 需 要 满 足 一 定 的 要 求 ： 第 一 个 要 求 是 ， 数 据 必 须 是 一 种 由 列 表 \n",
    "# 元 素 组 成 的 列 表 ， 而 且 所 有 的 列 表 元 素 都 要 具 有 相 同 的 数 据 长 度 ；第 二 个 要 求 是 ，数 \n",
    "# 据 的 最 后 一 列 或 者 每 个 实 例 的 最 后 一 个 元 素 是 当 前 实 例 的 类 别 标 签 。数 据 集 一 旦 满 足 \n",
    "# 上 述 要 求 ，我 们 就 可 以 在 函 数 的 第 一 行 判 定 当 前 数 据 集 包 含 多 少 特 征 属 性 。我 们 无 需 \n",
    "# 限 定 list 中 的 数 据 类 型 ， 它 们 既 可 以 是 数 字 也 可 以 是 字 符 串 ， 并 不 影 响 实 际 计 算 。\n",
    "def chooseBestFeatureTooSplit(dataSet):\n",
    "    numFeatures = len(dataSet[0]) - 1  # 特征总数\n",
    "    baseEntropy = calcShannonEnt(dataSet)  # 原始香农熵\n",
    "    bestInfoGain = 0.0  # 当前最好香农熵\n",
    "    bestFeature = -1  # 特征量\n",
    "    for i in range(numFeatures):\n",
    "        featList = [example[i] for example in dataSet]  # 提取第一个特征的所有特征值\n",
    "        uniqueVals = set(featList) # 去重\n",
    "        newEntropy = 0.0  # 特征 i 的信息熵，注意特征 i 的每个值的熵应该计算比例\n",
    "        for value in uniqueVals:\n",
    "            subDataSet = splitDataSet(dataSet, i, value)\n",
    "            prob = len(subDataSet) / float(len(dataSet))\n",
    "            newEntropy = newEntropy + prob * calcShannonEnt(subDataSet)\n",
    "        infoGain = baseEntropy - newEntropy  # 当前最好的熵与新熵的差值\n",
    "        if infoGain > bestInfoGain:  # 差值越大说明该划分越好，更新熵值和特征量\n",
    "            bestInfoGain = infoGain\n",
    "            bestFeature = i\n",
    "    return bestFeature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "myDat, labels = createDataSet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chooseBestFeatureTooSplit(myDat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 递归构建决策树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 多数表决：当特征属性划分完时仍不能确定类标签时使用\n",
    "def majorityCnt(classList):\n",
    "    classCount = {}\n",
    "    for vote in classList:\n",
    "        if vote not in classCount.keys():\n",
    "            classCount[vote] = 0\n",
    "        classCount[vote] += 1\n",
    "    sortedClassCount = sorted(classCount, key=operator.itemgetter(0), reverse=True)\n",
    "    return sortedClassCount[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 递归创建树\n",
    "def createTree(dataSet, labels):\n",
    "    classList = [example[-1] for example in dataSet]  # 提取特征列\n",
    "    \n",
    "    if classList.count(classList[0]) == len(classList): # 若剩下的都是同一类别则直接返回标签值\n",
    "        return classList[0]\n",
    "    if len(dataSet[0]) == 1:  # 若特征遍历完仍未完成划分，则返回出现次数最多的标签值\n",
    "        return majorityCnt(classList)\n",
    "    \n",
    "    bestFeat = chooseBestFeatureTooSplit(dataSet)\n",
    "    bestFeatLabel = labels[bestFeat]  # 根据最好的特征找到特征标签\n",
    "    myTree = {bestFeatLabel:{}}\n",
    "    del labels[bestFeat]  # 删除该特征标签\n",
    "    \n",
    "    featValues = [example[bestFeat] for example in dataSet]  # 提取该特征的所有属性值\n",
    "    uniqueVals = set(featValues)\n",
    "    for value in uniqueVals:\n",
    "        subLabels = labels[:]\n",
    "        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), subLabels)\n",
    "    return myTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "myDat, labels = createDataSet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myTree = createTree(myDat, labels)\n",
    "myTree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 绘制树形图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 下面定义树节点格式的常量\n",
    "decisionNode = dict(boxstyle='sawtooth', fc='0.8')\n",
    "leafNode = dict(boxstyle='round4', fc='0.8')\n",
    "arrow_args = dict(arrowstyle='<-')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 执行实际绘图功能\n",
    "# 该函数需要一个绘图区，该区域由全局变量 createPlot.ax1 定义\n",
    "def plotNode(nodeTxt, centerPt, parentPt, nodeType):\n",
    "    createPlot.ax1.annotate(nodeTxt,\n",
    "                           xy=parentPt,\n",
    "                           xycoords='axes fraction',\n",
    "                           xytext=centerPt,\n",
    "                           textcoords='axes fraction',\n",
    "                           va='center',\n",
    "                           ha='center',\n",
    "                           bbox=nodeType,\n",
    "                           arrowprops=arrow_args)\n",
    "\n",
    "def createPlot():\n",
    "    fig = plt.figure(1, facecolor='white')\n",
    "    fig.clf()\n",
    "    createPlot.ax1 = plt.subplot(111, frameon=False)\n",
    "    plotNode('a decision node', (0.5, 0.1), (0.1, 0.5), decisionNode)\n",
    "    plotNode('a leaf node', (0.8, 0.1), (0.3, 0.8), leafNode)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "createPlot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 获取所有叶节点数目\n",
    "def getNumLeafs(myTree):\n",
    "    numLeafs = 0\n",
    "    firstStr = list(myTree.keys())[0]  # 得到当前节点的所有孩子节点中的第一个\n",
    "    secondDict = myTree[firstStr]  # 得到 firstStr 节点的所有子树（字典类型）\n",
    "    for key in secondDict.keys():  # 遍历所有子节点（包括递归遍历子树子节点）\n",
    "        if type(secondDict[key]).__name__ == 'dict':\n",
    "            numLeafs += getNumLeafs(secondDict[key])\n",
    "        else:\n",
    "            numLeafs += 1\n",
    "    return numLeafs\n",
    "\n",
    "# 获取树的层数（不计算根节点）\n",
    "def getTreeDepth(myTree):\n",
    "    maxDepth = 0\n",
    "    firstStr = list(myTree.keys())[0]\n",
    "    secondDict = myTree[firstStr]\n",
    "    for key in secondDict.keys():\n",
    "        if type(secondDict[key]).__name__ == 'dict':\n",
    "            thisDepth = 1 + getTreeDepth(secondDict[key])\n",
    "        else:\n",
    "            thisDepth = 1\n",
    "        if thisDepth > maxDepth:\n",
    "            maxDepth = thisDepth\n",
    "    return maxDepth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 返回预设树\n",
    "def retrieveTree(i):\n",
    "    listOfTree = [{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}},\n",
    "                  {'no surfacing': {0: 'no', 1 : {'flippers': {0: {'head': {0: 'no',\n",
    "                  1: 'yes'}}, 1: 'no'}}}}]\n",
    "    return listOfTree[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'no surfacing': {0: 'no',\n",
       "  1: {'flippers': {0: {'head': {0: 'no', 1: 'yes'}}, 1: 'no'}}}}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "retrieveTree(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myTree = retrieveTree(0)\n",
    "myTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getNumLeafs(myTree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getTreeDepth(myTree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 在父节点间添加文本信息\n",
    "def plotMidText(cntrPt, parentPt, txtString):\n",
    "    xMid = (parentPt[0] - cntrPt[0]) / 2.0 + cntrPt[0]\n",
    "    yMid = (parentPt[1] - cntrPt[1]) / 2.0 + cntrPt[1]\n",
    "    createPlot.ax1.text(xMid, yMid, txtString)\n",
    "    \n",
    "def plotTree(myTree, parentPt, nodeTxt):\n",
    "    numLeafs = getNumLeafs(myTree)\n",
    "    depth = getTreeDepth(myTree)\n",
    "    firstStr = list(myTree.keys())[0]\n",
    "    cntrPt = (plotTree.x0ff + (1.0 + float(numLeafs)) / 2.0 / plotTree.totalW, \n",
    "              plotTree.y0ff)\n",
    "    plotMidText (cntrPt, parentPt, nodeTxt)\n",
    "    plotNode(firstStr, cntrPt, parentPt, decisionNode)\n",
    "    secondDict = myTree[firstStr]\n",
    "    plotTree.y0ff = plotTree.y0ff - 1.0 / plotTree.totalD\n",
    "    for key in secondDict.keys():\n",
    "        if type(secondDict[key]).__name__ == 'dict':\n",
    "            plotTree(secondDict[key], cntrPt, str(key))\n",
    "        else:\n",
    "            plotTree.x0ff = plotTree.x0ff + 1.0 / plotTree.totalW\n",
    "            plotNode(secondDict[key], (plotTree.x0ff, plotTree.y0ff),\n",
    "                    cntrPt, leafNode)\n",
    "            plotMidText((plotTree.x0ff, plotTree.y0ff), cntrPt, str(key))\n",
    "    plotTree.y0ff = plotTree.y0ff + 1.0 / plotTree.totalD\n",
    "    \n",
    "def createPlot(inTree):\n",
    "    fig = plt.figure(1, facecolor='white')\n",
    "    fig.clf()\n",
    "    axprops = dict(xticks=[], yticks=[])\n",
    "    createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)\n",
    "    plotTree.totalW = float(getNumLeafs(inTree))\n",
    "    plotTree.totalD = float(getTreeDepth(inTree))\n",
    "    plotTree.x0ff = -0.5 / plotTree.totalW\n",
    "    plotTree.y0ff = 1.0\n",
    "    plotTree(inTree, (0.5, 1.0), '')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADxCAYAAABoIWSWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3dZ1QVh/q28QsBQUCQZkFipVqxEXvDEnsJsfdjjNFYook1ioj9xMSuBBWNith7x95FBQsgRRG7iIiCCsJm3g/+D+/xJEZRYGDz/NZyrTiwZ27YeOdhqo6iKApCCCFyRAG1AwghRH4ipSuEEDlISldkSmJiIvXq1aNq1apER0dTq1YtatWqRXR0NFWqVKFBgwbcunULJycnmjVrRlRUFOXLl6dt27ZERERQqlQp3N3dCQ0NxcbGhl69enH16lWsra359ttvuXTpEhYWFgwfPpyzZ89iamrKuHHjOH78OCYmJnh5eXHgwAEKFSrE3Llz2bFjB4aGhixZsgR/f38MDAxYtWoVvr6+GBgY4O/vz9KlSzE0NGTHjh3MnTuXQoUKceDAAby8vDAxMeH48eOMGzcOU1NTzp49y4gRIzA3N+fSpUt8++23WFtbc/XqVXr16oWNjQ2hoaG4u7tTqlQpbt26pfZbIvIaRYhMaNOmjdKhQweld+/eip6entK1a1ela9euip6entKnTx+lY8eOip6envLtt98qrVq1UvT09JShQ4cqTZs2VfT19ZVRo0Yp9erVUwoWLKiMGTNGcXV1VQwMDJSJEycqLi4uiqGhoeLh4aFUrFhRMTIyUqZOnarY29srhQsXVqZPn66ULVtWMTMzU2bOnKnY2toqFhYWyqxZs5QSJUooVlZWyqxZs5RixYopxYoVU2bNmqVYWVkpJUqUUGbNmqVYWFgoX3zxhTJz5kzFzMxMKVu2rDJ9+nSlcOHCir29vTJ16lTFyMhIqVixouLh4aEYGhoqLi4uysSJExUDAwPF1dVVGTt2rFKwYEGlXr16ysiRIxVbW1slLS1N7bdF5CE6iiIH0sTH+/nnnwkICGDhwoXExMTg6OiIoihERETg6OhIeno6UVFRODo6kpaWxq1bt3BwcCA1NZWYmBjs7OxISUnh3r17lC9fnuTkZB49ekSZMmV4+fIlcXFxlC5dmqSkJJ49e8YXX3zBixcvePHiBba2tiQkJPDq1StsbGx49uwZKSkpFC9enKdPn6LRaChatChxcXEAWFlZERsbi66uLpaWljx69AgDAwPMzc158OABRkZGFClShHv37mFqaoqpqSl3797F3NwcExMTYmJisLa2xsjIiNu3b1O8eHEMDQ25desWNjY2zJ07lxcvXnDw4EEKFJBfGsXHkdIVmZKWloaDgwO9evWiQ4cOasdRTWRkJH369OH27dvY2NioHUfkIfK/Z5Epo0ePxtLSkpYtW6odBYCgoCC6dOlCjx49SE5OztRrN2/ezO7duz9pu3Z2dnTq1ImuXbuSnp7+SesQ+ZOe2gFE3nLr1i3KlCmDgYGB2lHQaDTs27ePXr160b59+0y/3t3d/ZO3raOjg4ODA2fOnCE9PV12L4iPJrsXRKY8f/6cqlWrMnjwYJo3b86DBw8YPnw4Li4uGWchzJ07F0NDQ8LDw5k5cybJycnY2toyefJkTE1N31lfQEAAf/zxB7q6upiYmODj48OuXbsIDQ1l7NixAIwcOZJevXpRs2ZNGjRoQM+ePTl79iwNGjTAz88PExMTqlSpwoQJExg9ejQvXrwgLS2N77//nsaNGwOwe/du1q5di46ODnZ2dnh5eeHt7Y2RkRG9e/dm0KBBVKpUiYsXL5KUlMSkSZOoVq0aycnJTJkyhdu3b1O2bFkePHjA2LFjMTY2plevXgQFBeHo6JjTb4PIw2TSFZmyc+dOUlJSqFSpUsayu3fvMn36dH755RfGjRvHkSNHaN26NR4eHvz888/UqFGDZcuW4ePjw+jRo99Zn4+PD4sWLaJo0aIkJiZ+cPuvX7+mfPnyDB48GIB79+5Rv359mjVrRlpaGv/+978xMTEhISGBfv360ahRI27dusXKlStZuXIlRYoU4fnz53+7bo1Gw59//smpU6fw8fFhyZIlbNq0icKFC+Pv709UVBQ9e/YEoFixYjg6OrJ06VJ+//13dHR0PvVbKvIZ+Z1IZMr8+fNxd3enRIkSGctsbGwypj0nJycePHhAUlISiYmJ1KhRA4C2bdty+fLlv6yvatWqTJkyhW3btqHRaD64fV1dXZo2bfrejy9evJhu3boxZMgQnjx5wtOnTwkMDMTNzY0iRYoAYGZm9revbdKkCQDOzs48ePAAgODg4Iz913Z2dtjZ2QFgaGjIwIEDWbZsGampqR/MLcR/SOmKTFm9ejUbNmwgODg4Y5m+vn7Gf+vq6n5Uef7HhAkTGDJkCI8fP6Znz54kJCSgq6vLf+/1evPmzTvr/8/Br5CQkHfWtW/fPhISEli7di1+fn5YWFhkvPZjJtGCBQv+5Wt43963uLg4PD092bBhQ8brhPgYUroiU9LS0j7qwJGJiQmmpqYEBQUBsGfPHqpXr/6Xz7t37x6VKlVi8ODBmJmZ8fjxY2xsbIiIiCA9PZ1Hjx5llOvBgwd58+ZNxlTt6emZcU4uQFJSEubm5ujp6XHx4kUePnwIQK1atQgICCAhIQHgvbsX/o6LiwuHDh0C3h5EjIqKAt6WeIECBUhJSfnodQkBsk9XZFL//v3p0aMHVapU+eDnTpkyJeNAWsmSJfHw8PjL58yfP587d+6gKAqurq44ODgAb3dZdOvWjfLly+Po6Mj58+fZuXMnBgYGODk5ZWT57bffMqbRVq1a8eOPP9K7d28cHBwoU6YMAOXLl2fAgAEMGjQIXV1dHB0dmTJlykd9vd988w0eHh5069YNR0dH7O3tMTExwdLSEg8PD3r16kXHjh1l2hUfTc5eEJmyceNGhg8fjre3N7a2tjmyzR07drBs2TIWL15MuXLlMpZrNBq6d+/OiBEjqFevXrZsW6PRkJaWhoGBAffu3eP7779n69atpKamMmTIENq0acOsWbOyZdtCO8mkKzKlefPmGBgYEB4eniOlu3nzZnx9fVm2bBmlS5d+52O6uroMGjSIZcuWUbdu3Ww5gyA5OZnBgweTlpaGoiiMGzcOfX19Hj16xM2bN+ndu3eWb1NoN9mnKzKlR48e1KlThy+//BJfX19evHjB8+fP8fX1JSkpifj4eFatWsXr16958uQJq1evJiUlhYcPH7JmzRpSU1O5e/cu69atIy0tjejoaPz9/UlPTycyMpLNmzejKAphYWFMmDCB1atXM2rUKK5evQq8vQJt3759AAQGBqLRaNBoNHh7e3P06FEATp48ycmTJwE4evQoZ8+eBeDQoUMEBgYCbw+6BQUFoSgKu3bt4tq1ayiKwrZt2wgLC0NRFDZv3syDBw9YvXo1HTp0YObMmXz55ZesW7cOgDFjxtC8eXPS0tJy9D0QeZvsXhCZMnHiRLZu3YqhoWFG2SiKgo6ODnp6erx8+RIDAwMKFSpEXFwcxsbGGTeSMTMzw8LCgsjISCwsLChatCihoaFYWFhQsmRJgoODsbS0pEyZMpw8eZI3b95Qv359rl69SpEiRahYsSJnzpzBxMSEqlWrcvr0aYyMjLCxseHixYsULVoUV1dXzp07B0Dt2rUJDAwkNTWVunXrcunSJV6/fk29evW4cuUKiYmJ1K1bl9DQUJ4/f46rqyuRkZEkJCRQo0YNoqOjiY+Px8XFhfv37xMfH0+FChWIjY0lPj4eBwcHChUqxN69e+U8XfHRZNIVmTJt2jS6d+9OixYtuHLlCh07dqRz585cuXKF5s2b07dvX4KDg6lbty5Dhw7l8uXLuLi4MGbMGC5evIiDgwOenp4EBgZSunRp5syZw4ULFyhWrBiLFy/m/PnzPHjwgCJFinD58mWsrKzw8/PjzJkz6OnpsWXLFk6dOgW8vcrs+PHjWFtb4+TkxJgxY9BoNAQEBBAQEIBGo+Ho0aPs37+f9PR0Tp48ye7du9HR0eH06dNs3boVfX19zpw5w7p16zA2NubcuXOsWLGCIkWKcOHCBRYvXkzx4sW5cOECc+bMoXTp0gQGBuLp6YmdnR3bt2+XwhWZIpOuyDUURWHKlCls2rSJw4cPv3MBxoccOHCAESNGcP36dfT05FCFyL1k0hW5gqIojB8/nm3btnHs2LFMFS5AixYtsLa2xs/PL5sSCpE1ZNIVqlMUhdGjR3Ps2DEOHTqEpaXlJ63n2LFj/Otf/+LGjRvvXCUnRG4ik65QVXp6OsOGDePUqVMcPnz4kwsXoHHjxpQtW5bVq1dnYUIhspZMukI16enpfPfdd4SGhrJ379733ogmM86ePUu3bt2IiIjIFff8FeJ/yaQrVKHRaBgwYAARERHs378/SwoXoE6dOlSqVInly5dnyfqEyGoy6Yocl5aWRp8+fYiNjWXHjh0YGxtn6fovXbpE+/btiYqKolChQlm6biE+l0y6IkelpqbSvXt3nj17xq5du7K8cAFq1KiBq6srS5cuzfJ1C/G5ZNIVOSYlJYUuXbqgKAqbNm3K1n2u165do3nz5kRFRWFiYpJt2xEis2TSFTni9evXdOrUCX19fTZv3pztB7kqV65M48aNWbhwYbZuR4jMkklXZLtXr17RoUMHrKysWLNmTY5dMXbjxg0aNGhAVFRUlh2oE+JzyaQrslVSUhKtW7emRIkSrF27Nkcv0XVycqJ169b8/vvvObZNIT5EJl2RbV68eEHr1q1xcnLC29sbXV3dHM9w8+ZNvvzySyIiIrCwsMjx7Qvxv2TSFdni2bNnNG/enCpVqvDHH3+oUrjw9lE9nTt35tdff1Vl+0L8L5l0RZZ7+vQpzZs3p1GjRvz222+q3/rwzp07VKtWjbCwMIoWLapqFiFk0hVZKjY2liZNmtCiRYtcUbgApUqVokePHsyePVvtKELIpCuyzsOHD2nWrBlff/01np6euaJw/+Phw4dUrFiR69evY2Njo3YckY9J6Yoscf/+fZo2bUrv3r355Zdf1I7zt0aPHk1KSgqLFi1SO4rIx6R0xWeLiYnBzc2N7777jp9//lntOO8VGxuLs7Mzly9f/suThYXIKVK64rPcunULNzc3Ro4cyYgRI9SO80ETJkzgyZMn+Pj4qB1F5FNSuuKTRUZG4ubmxvjx4/n+++/VjvNR/vMU33PnzmFnZ6d2HJEPydkL4pOEhYXRpEkTPDw88kzhAlhYWDBs2DCmTp2qdhSRT8mkKzLt2rVrtGzZktmzZ9O7d2+142Ta8+fPsbOz4+TJkzg5OakdR+QzUroiU4KCgmjVqhXz58+na9euasf5ZLNmzSI4OBh/f3+1o4h8RkpXfLTAwEDatm3L0qVL6dy5s9pxPktSUhJ2dnYcPHiQKlWqqB1H5CNSuuKjnDlzho4dO7JixQratWundpws8fvvv3PixAm2bdumdhSRj0jpig86ceIE7u7u/Pnnn3z11Vdqx8kyr1+/xs7Ojh07dlCzZk2144h8QkpX/KPDhw/TrVs3/P39cXNzUztOllu8eDF79uxh7969akcR+YSUrniv/fv306dPHzZv3kzDhg3VjpMtUlJScHBwYP369dStW1ftOCIfkPN0xd/atWsXffr0Yfv27VpbuAAGBgZMmjSJSZMmqR1F5BNSuuIvtm7dysCBA9mzZ0++mP769u1LTEwMR48eVTuKyAekdMU7/P39GTJkCPv376dWrVpqx8kR+vr6eHh4MGnSJGRvm8huUroiw59//smoUaM4dOgQ1apVUztOjurRowdPnz7l4MGDakcRWk5KVwCwYsUKJkyYwOHDh6lcubLacXKcrq4unp6eMu2KbCelK1i6dCmenp4cOXIEZ2dnteOoxt3dnZSUFHbt2qV2FKHF5JSxfG7+/PnMmzePw4cPU65cObXjqG7Hjh14eHhw+fJlChSQmURkPfmpysfmzJnDwoULOXbsmBTu/2nfvj36+vps2bJF7ShCS8mkm09NmzaNNWvWcOTIEUqWLKl2nFxl3759jB49mmvXrqGrq6t2HKFlZNLNZxRFYfLkyaxfv57jx49L4f6Nr776CnNzc9avX692FKGFZNLVcvv372fEiBFoNBr+9a9/kZCQwL59+wgICKBo0aJqx8u1jhw5wnfffUdYWBh6enoZywcMGMDu3bspWrQo169fVzGhyKukdLWYRqPBwcGBQ4cOUbJkSWxtbbG2tubkyZNYWlqqHS/Xa9q0Kb169WLAgAEZy06cOIGJiQl9+vSR0hWfRHYvaLELFy5gZ2dHmTJlGDVqFIaGhri7u0vhfiQvLy+mTp3KmzdvMpY1bNgQCwsLFVOJvE5KV4vdv38fW1tbBg0aRHBwMJMmTSI+Pl7tWHlGvXr1cHJyYsWKFWpHEVpESleLaTQaTpw4QVRUFAcOHKBQoULo6OioHStP8fLyYvr06bx+/VrtKEJLSOlqqdTUVJYvX058fDx79+7FxMSEe/fuYWNjo3a0PKVWrVrUqFEDb29vtaMILSGlq4XevHlDt27d0NXVxdTUlMePH/PmzRv8/f1p37692vHynKlTpzJ79mxevnypdhShBaR0tUxKSgru7u5oNBp27NjB4sWLadmyJc7OznTp0oWKFSuqHTHPqVq1Kg0aNGDRokV0796dOnXqEB4ejq2trezvFZkmp4xpkdevX9O5c2dMTEzw8/NDX19f7UhaIzQ0lMaNGxMVFYWpqanacUQeJpOulnj58iXt2rXLuJJKCjdrVahQgZYtWzJ//ny1o4g8TiZdLZCYmEjbtm0pW7YsK1askPsFZJOoqChq165NZGQk5ubmascReZRMunnc8+fPadmyJY6OjqxcuVIKNxvZ2dnRsWNH5s6dq3YUkYfJpJuHPXv2jJYtW+Lq6sqCBQvk/q85ICYmhurVq3Pjxg2sra3VjiPyIPlXmkfFxcXh5uZG/fr1WbhwoRRuDildujRdu3Zlzpw5akcReZRMunlQbGwszZo1o02bNsyYMUOuMsth9+/fp3LlyoSEhFCiRAm144g8Rko3j3n48CFubm506dIFDw8PKVyV/Pjjj2g0GhYsWKB2FJHHSOnmIffu3aNp06b069ePCRMmqB0nX3v8+DHOzs5cuXKFL774Qu04Ig+R0s0jYmJiaNq0Kd9//z0//fST2nEEMG7cOJ49eyb3ZRCZIqWbB9y8eRM3NzdGjRrF8OHD1Y4j/s/Tp09xcHAgMDBQHuwpPpoc8s7lwsPDady4MePHj5fCzWUsLS354Ycf8PLyUjuKyENk0s3FQkNDad68OdOmTaN///5qxxF/IyEhAXt7e06dOoWjo6PacUQeIJNuLnX16lWaNWvG7NmzpXBzsSJFijBy5Eg8PT3VjiLyCJl0c6HLly/TunVrFixYQJcuXdSOIz4gMTEROzs7Dh8+TKVKldSOI3I5Kd1c5sKFC7Rr145ly5bRqVMnteOIj/Trr79y9uxZtmzZonYUkctJ6eYip0+fplOnTqxcuZK2bduqHUdkwqtXr7Czs2P37t1Ur15d7TgiF5PSzSWOHz/ON998w9q1a2nRooXaccQnWLhwIQcOHGD37t1qRxG5mJRuLhAQEECPHj3w9/enadOmascRnyg5ORkHBwc2btxI7dq11Y4jcikpXZXt27ePvn37smXLFho0aKB2HPGZ/vjjDzZv3szBgwfVjiJyKTllTEU7d+6kb9++7NixQwpXS/Tv35+oqChOnDihdhSRS0npqmTLli0MGjSIvXv3UqdOHbXjiCyir6+Ph4cHv/zyC/JLpPg7UroqWL9+PT/88AP79++nZs2aascRWaxnz548fvyYgIAAtaOIXEhKN4etXr2an376iUOHDuHi4qJ2HJEN9PT0mDJlCpMmTZJpV/yFlG4OWr58ORMnTpQrl/KBrl278vLlS/bu3at2FJHLyNkLOWTJkiXMnj2bgIAA7O3t1Y4jcsDWrVuZNm0aly5dkid8iAwy6eaAefPm8euvv3Ls2DEp3HzkP5dxb9u2TeUkIjeRSTebzZ49m+XLl3P48GFKlSqldhyRw/bs2cPYsWO5cuUKurq6ascRuYBMutnIy8sLX19fjh07JoWbT7Vu3RoTExM2btyodhSRS8ikmw0URWHy5Mls3bqVw4cPU7x4cbUjCRUFBAQwdOhQQkJC0NPTUzuOUJlMullMURTGjh3Lrl27OHbsmBSuwM3NjeLFi7N27Vq1o4hcQCbdLKQoCj/++COnTp3i4MGDWFhYqB1J5BInTpygX79+hIeHo6+vr3YcoSKZdLNIeno6Q4YM4fz58wQEBEjhinc0bNgQOzs7fH191Y4iVCaTbhbQaDQMGjSIiIgI9uzZg6mpqdqRRC50/vx53N3diYyMxNDQUO04QiUy6X6mtLQ0+vfvT3R0NPv27ZPCFe/15Zdf4uLigo+Pj9pRhIpk0v0Mqamp9O7dm/j4eLZv346RkZHakUQuFxQURJs2bYiKipKfl3xKJt1P9ObNG7p27UpSUhI7d+6Uf0Dio1SrVo06deqwZMkStaMIlUjpfoLk5GS+/vprFEVh69atsn9OZIqnpyf//ve/SUxMpHXr1jx48EDtSCIHSel+BEVRMm7R9/r1azp27EihQoXYuHEjBQsWVDmdyEtSU1MpV64cbm5uLFiwgJiYGJ49e6Z2LJGDpHQ/wooVK5g0aRIvX76kbdu2WFlZ4efnJ+dbikw7f/489vb2NG/enHnz5qEoChqNRu1YIgdJ6X6ElStX4uLiQqtWrShVqhSrV6+WyznFJ6lfvz6rV6/ml19+wcbGhri4OCndfEZK9wNu375NREQEv/76KxUqVGDOnDnyj0R8lmbNmnH58mWKFCnCkydPeP78udqRRA6S0v0AX19f0tLS0NfXJzQ0FHt7ey5cuKB2LJHHFStWjKNHjzJ27FiqVKmidhyRg+Q83Q+wtrbm5cuXdO/enc6dO+Pm5iZnKwghPplMuh8QGBjI8+fPWbFiBW3atJHCFX8RFxfHpUuXAEhMTOT06dPA23O5jx49iqIopKenc/jwYdLS0lAUhRMnTvDq1Svg7cG1/5zBcOXKFR4+fAhAeHg40dHRwNvdXDdu3ADg0aNHBAcHA/Ds2TPOnz8PvD2z5vjx4yiKQlpaGocPHyY9PR1FUTh27Bhv3rzJoe+I+EeKFouKilKmTZum9OvXT6lfv75SsmRJRUdHRwHe+aOjo6OULFlSqV+/vtKvXz9l2rRpSlRUlNrxRR7w+PFjxcnJSSlcuLAyf/58xdXVVTE2NlamTJmitGrVSjE2NlaGDBmi9O3bVzE2NlY6d+6sjBkzRjE2NlYaNmyozJkzRzExMVEqVaqkLFu2TDEzM1NKlSqlrF69WrGwsFCsra2VNWvWKEWLFlXMzc2VVatWKaVLl1ZMTU2VJUuWKFWqVFFMTEyUWbNmKY0bN1aMjY2Vn376SXF3d1eMjY2VXr16KT/88INiZGSktGnTRklJSVH7W5bvae2ke/r0aWrVqkVISAglS5akR48eLF26lLNnz3Lx4sV3/pw9e5alS5fSo0cPSpYsSUhICLVq1cqYWIR4n59//pkvvvgCX19f5s6di52dHZs3b8bf3x+AHTt2EBgYSGRkJDt27CAhIYH9+/ezdetWrKysWLZsGX5+ftSuXRtPT8+Mn8NRo0YxY8YMfvrpJ4YPH86oUaOYNWsWP/30E127dsXb25vp06dTs2ZN1q9fz/LlyzE3N2fbtm0cPHiQuLg4du7cSXR0NGfPnmXHjh2Ehobyxx9/qPwdE1q7T7dly5bUrVuXtm3bftLrd+/ezZkzZzhw4EAWJxPa5MqVK7i5ueHl5YWrq6vacd5r/fr17Nq1i9OnT2NlZaV2nHxNayfd69evU61atU9+vYuLCyEhIVmYSGgjZ2dnHB0duX79utpR/lFQUBDNmjWTws0FtLJ0ExMTefbsGSVKlPjkdZQoUYKnT5+SlJSUhcmEthk3bhwFChSgT58+Gcv8/f1xd3enVatWzJ49G4DNmzeze/dutWIyceJE9uzZw/r161XLIN7SytINDw+nTJkyFCjw6V+erq4uZcqUyThiLMTfqVWrFlFRUTx58iRj2aZNm5g/fz5DhgzJWObu7v7Ju7o+hvJ/Z0i8T2RkJElJSTg7O2dbBvFxtPJa1oSEBMzMzN5Z9uDBA4YPH46LiwtXr17F2tqauXPnEhMTw8yZM0lOTsbW1pbJkydn3Ii8SJEiJCQkqPEliDyie/furF27Fn9/f3788UdmzJjB/fv3GTVqFO3bt8/4PG9vb4yMjOjduzeDBg3C0dGRkJAQkpKSmDx5MpUqVcLb25t79+7x5MkTHj9+TJ8+fejUqRMAf/75JwEBAbx584YmTZrw3XffZfxM16xZk6tXrzJ37ly8vb0JDQ1FR0eH9u3b07NnTwB8fHwYOnQoLi4uqnyfxP+nlZPu+9y9e5dvvvmGjRs3UrhwYY4cOYKHhwfDhg3D398fOzs7uau/yJQlS5YQGhpKv379AJgwYQLW1tZ4e3v/41NEXr9+zcqVKxk3bhxTp07NWB4VFcW8efPw9fVl+fLlPHnyhHPnznH37l1Wr16Nn58fYWFhXL58GYCYmBjatGmDn58fCQkJxMbGsnHjRjZs2PBO6f/4448sXrxYzsjJBfJV6drY2ODo6AiAk5MT9+7dIzExkRo1agDQtm3bjB9mIT7Gw4cPsbS0zPRN7Fu2bAlA9erVefnyJYmJiQA0atQIQ0NDihQpQo0aNQgJCeHcuXOcO3eOnj170qtXL27fvs2dO3eAt8ceKleuDEDJkiW5f/8+c+bM4cyZMxgbG2dsz9zcHAMDA54+fZoVX7b4DPmqdP/7Voy6uroZP+hCfCpPT0/MzMxYsWJFpl6no6Pzt39PT09n1apVJCUlZVyNpigK/fr1w8/PDz8/P7Zv307Hjh0B3rlC0tTUlPXr11OjRg02bdqEl5dXxsemT59Ojx493pl+hTq0snSNjY0zLrH8JyYmJpiamhIUFATAnj17qF69esbHX758+c60IMT/OnXqFFeuXKFRo0aZet3Bg9wZ2KcAABbYSURBVAcBCA4OxsTEBBMTE+Dt+eGBgYG8evWK8PBw9PT0qFOnDjt37sz4mY6NjSU+Pv4v60xISCA9PR03NzcGDx5MeHh4xsdatGiBv79/xoQs1KOVB9IcHByIjo5GUZS/TBT/a8qUKRkH0kqWLImHhwfwdrq4fft2xu4IIf7OqlWrqFmzJhUqVMjU60xNTRkwYEDGgTR4+2TpxMREXrx4wXfffUeLFi3YsGEDCxcuJDo6mv79+wNgZGSEl5fXX87OiY2NxdPTM+MpJ0OHDs34WIsWLVi7di179+5l8ODBn/Mli8+ktVekWVtbs2bNGqytrT/p9bGxsfTp0+edU4GE+F/x8fE0aNCAjh070rlz5496zaBBgxg5cuRfinrYsGE8fvyYjRs3Am8f7dO5c2e8vLw++6yD6dOnoygKmzdvRldX97PWJT6PVu5egLcHykJDQz/59aGhoXJOo/ig169fk5SU9NlPg05OTiY4OJjatWtnLNPX12fgwIEsW7bsc2NibGzMs2fPSE1N/ex1ic+jO2XKlClqh8gOZmZmTJo0iYIFC5KSkoKuri6FChV67+6G9PR0njx5QkREBKdPn2bJkiVMnTo10782ivxl2LBhGBkZ0aVLFyZOnEhiYiJly5Zl6tSpREdHU6VKFebMmcOFCxdwdXVl2bJl6Onp0b59ezZs2MDatWupU6cO06ZNIy4uDk9PT65evcqMGTOoVKkSRkZGrFy5ksKFC1O4cGHGjRuHubk5RkZGjB8/Ho1Gg42NDZMnT+bRo0c4OTkxY8YMrl27Ro0aNViwYAFHjx5lxIgR+Pr6UrBgQb788ku1v235mtbuXgA4dOgQvr6+3Lp1i1u3bvHixQuKFy/+l1+vNBoNjx49wtTUlHLlylGuXDn69+9P8+bNVUou8oqQkBDc3NzQ09OjXbt27N27Fx0dHerUqcP169dJSkrCwcGB5ORk7ty5g5WVFba2tgQHB6Onp0f9+vUJCAjgwYMH9OjRgyNHjpCSksLAgQPx9fVFo9FQt25d9u3bh4WFBf369WPFihUYGhrSuXNnNm/ejL6+Pk2aNOHMmTOkpqZStWpVHj58SGxsLLa2tpiYmBAaGoq5uTlHjhzBwsJC7W9b/qbOHSXVkZSUpISHhythYWHv/AkPD1eSkpLUjifyqLCwMGXdunVKenq6EhMTo/j4+CgajUZ5+vSpsmjRIiU5OVl5+fKlsnDhQuX58+dKamqqsnTpUuXhw4dKenq60rlzZ6V9+/aKoijKpk2blKCgIEVRFGXfvn3KyZMnlbS0NKVMmTKKp6enoiiKEhwcrGzcuFFRlLf3jPb19VXS09OVR48eKUuWLFFSU1OVFy9eKAsWLFBevnyppKSkKIsXL1aePn2qzjdIvEOrJ10hcrtnz55hb2/P2bNnsbe3f+/nbdq0KWM3xYfOyBG5m9YeSBMiL/jtt9/o0KHDPxYuwNdff01qaio7d+7MoWQiu8ikK4RK4uLicHR05NKlS5QpU+aDn79z505++eUXgoODP+sOekJd8s4JoZI5c+bQtWvXjypcgHbt2mFoaMjmzZuzN5jIVjLpCqGCR48eUbFiRa5evUrJkiU/+nUHDhxg5MiRXL9+XS5yyKNk0hVCBTNnzqRPnz6ZKlx4ezmvpaUlfn5+2ZRMZDeZdIXIYffu3aNq1aqEhoZSrFixTL/+2LFjDBw4kLCwsHfunCfyBpl0hchh06dPZ+DAgZ9UuACNGzemdOnSrF69OouTiZwgk64QOSg6OpqaNWsSERGBpaXlJ6/nzJkzdO/enYiICAwMDLIwochuMukKkYO8vLwYOnToZxUuQN26dalYsSLLly/PomQip8ikK0QOiYiIoF69ekRGRlKkSJHPXt/Fixfp0KEDUVFRFCpUKAsSipwgk64QOcTT05ORI0dmSeEC1KxZM+POZSLvkElXiBwQEhJC06ZNiYqKonDhwlm23qtXr9KiRQuioqIyHvkjcjeZdIXIAR4eHvz8889ZWrgAVapUoVGjRixatChL1yuyj0y6QmSzoKAg2rRpQ1RU1Gc/YeLvhIWF0bBhQ6KiojAzM8vy9YusJZOuENls8uTJjBs3LlsKF8DZ2ZlWrVoxb968bFm/yFoy6QqRjc6fP4+7uzuRkZEYGhpm23Zu3rzJl19+SUREhDwZIpeTSVeIbDR58mR++eWXbC1cgPLly9OpUyd+/fXXbN2O+Hwy6QqRTU6ePEnfvn25ceMGBQsWzPbtxcTEUL16dcLCwihatGi2b098GildIbKBoig0btyY/v37069fvxzb7g8//ICBgQFz587NsW2KzJHSFSIbBAQEMHToUEJCQtDT08ux7T548IBKlSpx/fp1bGxscmy74uNJ6QqRxRRFoW7dugwfPpzu3bvn+PZHjx7NmzdvWLhwYY5vW3yYlK4QWWzv3r2MGTOGq1evqvIss9jYWJydnQkKCqJUqVI5vn3xz6R0hchCiqJQs2ZNJkyYwNdff61ajvHjx/P06VP++OMP1TKIvyenjAmRhbZv346iKHTq1EnVHD///DNbt27l5s2bquYQfyWTrhBZJD09napVqzJz5kzatm2rdhymTJlCdHS0PGEil5FJV4gssnHjRoyNjWnTpo3aUQD48ccf2bt3Lzdu3FA7ivgvMukKkQXS0tKoVKkSCxcupHnz5mrHyTBz5kyuXLmCv7+/2lHE/5FJV4gssG7dOooWLUqzZs3UjvKOYcOGcezYMa5du6Z2FPF/ZNIV4jOlpqbi6OjIqlWraNiwodpx/uK3337j1KlTbN26Ve0oApl0hfhsvr6+lC9fPlcWLsD333/P+fPnuXTpktpRBDLpCvFZUlJSsLe3Z+PGjdSuXVvtOO+1ePFi9u7dy549e9SOku/JpCvEZ/Dx8aFKlSq5unABBg4cyPXr1zl79qzaUfI9mXSF+ESvXr3Czs6O3bt3U716dbXjfJCPjw8bNmwgICBA7Sj5mky6QnyipUuXUqdOnTxRuAD9+vUjOjqaY8eOqR0lX5NJV4hPkJiYiJ2dHYcPH6ZSpUpqx/lof/75Jz4+Ppw4cQIdHR214+RLMukK8QkWLlxI06ZN81ThAvTs2ZO4uDgOHTqkdpR8SyZdITIpISEBe3t7Tp06haOjo9pxMm3Dhg3MnTuX8+fPy7SrApl0hciE/fv3Y2dnR0pKCtu2bVM7zif55ptvSE5OZvfu3e8sHzBgAEWLFs1z03teI6UrxEfSaDR8//33aDQaLly4wPr16wkNDVU7VqYVKFCAqVOnMnnyZNLT0zOW9+vXj/3796uYLH+Q0hXiI124cAGALl264OTkRLdu3dixY4fKqT5Nhw4d0NXVfefS4IYNG2JhYaFiqvxBSleIjxQaGsrDhw+ZOHEiALa2tty/f1/lVJ9GR0cHLy8vPDw80Gg0asfJV6R0hfhI27Zto3z58u88dywvH4j66quvMDMzk9s+5jApXSE+wv379zlx4gTW1tYZy+7du5enH3P+n2nX09OTtLQ0tePkG1K6QnyEGTNmMHDgQO7cuUN0dDRv3rzB39+f9u3bqx3tszRt2pSSJUuyZs0ataPkG3KerhAfEBMTQ/Xq1blx4waBgYGMHDkSjUbDgAEDMvbv5mWnTp2id+/euLq6cuLECeLi4ihWrBienp7861//Ujue1pHSFeIDBg4cSLFixZg+fbraUbJNy5Yt6dSpE4MHD1Y7itaT0hXiH0RFRVG7dm0iIyMxNzdXO062uXDhAl9//TWRkZEYGhqqHUeryT5dIf6Bp6cnw4cP1+rCBXB1daVatWp4e3urHUXryaQrxHuEhYXRqFEjoqKiMDU1VTtOtgsODqZVq1ZERUVhbGysdhytJZOuEO8xZcoURo8enS8KF8DFxYX69euzePFitaNoNZl0hfgbV65coWXLlty8eTNfTX0hISE0adKEmzdvUrhwYbXjaCWZdIX4Gx4eHowbNy5fFS5AxYoVadGiBfPnz1c7itaSSVeI/xEYGEinTp2IiorKl0fyIyMjqVOnjtafsaEWmXSF+B+TJ09m4sSJ+bJwAezt7enQoQO//fab2lG0kky6QvyX06dP07NnTyIiIihYsKDacVRz+/ZtatSoQXh4OFZWVmrH0Soy6QrxXyZNmsSkSZPydeEClClThi5dujBnzhy1o2gdmXSF+D9Hjx5l0KBBhIaGoq+vr3Yc1d27d4+qVasSEhJC8eLF1Y6jNaR0hQAURaFBgwYMHjyYXr16qR0n1xg5ciSKosjZDFlISlcI3j5wctSoUVy7dg1dXV214+Qajx49okKFCly9ehVbW1u142gFKV2R7ymKgqurK2PGjOGbb75RO06uM3bsWF68eMHSpUvVjqIVpHRFvrdjxw4mT55MUFAQBQrIseX/FRcXh6OjIxcvXqRs2bJqx8nz5CdM5Gvp6elMnjwZLy8vKdz3sLKyYujQoXh5eakdRSvoqR1ACDVt2bIFAwMD2rVrp3aUXG3UqFHY29sTERGBg4OD2nHyNNm9IPItjUZD5cqV+f3332nZsqXacXK9adOmERYWxrp169SOkqfJ71Mi31q/fj0WFha0aNFC7Sh5wogRIwgICCAkJETtKHmaTLoiX0pNTcXZ2RkfHx+aNGmidpw849///jfnz59n8+bNakfJs2TSFfnSn3/+SenSpaVwM2no0KGcOXOG4OBgtaPkWTLpinwnJSUFR0dH/Pz8qFu3rtpx8pwFCxYQEBDAzp071Y6SJ8mkK/KdFStWUKFCBSncTzRo0CCCgoI4f/682lHyJJl0Rb7y+vVr7O3t2b59OzVr1lQ7Tp7l7e3N1q1bOXDggNpR8hyZdEW+4u3tTc2aNaVwP1P//v2JiIjg5MmTakfJc2TSFfnGy5cvsbOz48CBA1SpUkXtOHneqlWrWLVqFUePHkVHR0ftOHmGTLoi31i0aBENGzaUws0ivXr14uHDhxw5ckTtKHmKTLoiX3jx4gV2dnYcP34cZ2dnteNoDT8/PxYuXMiZM2dk2v1IMumKfGHevHl89dVXUrhZrGvXriQmJrJv3z61o+QZMukKrRcfH4+DgwPnzp3Dzs5O7ThaZ8uWLcyYMYOLFy/KtPsRZNIVWm/u3Ll06tRJCjebdOrUifT0dLZv3652lDxBJl2h1Z48eYKTkxOXL1+mdOnSasfRWrt372b8+PFcuXJF7kv8AfLdEVptzpw5dO/eXQo3m7Vp0wZjY2M2bdqkdpRcTyZdobUePnxIpUqVuHbtGjY2NmrH0XqHDh1i2LBhXL9+HT09eT7C+8ikK7TWzJkz6du3rxRuDmnWrBlFixbFz89P7Si5mky6QivduXOHatWqERYWRtGiRdWOk28cP36cAQMGcOPGDfT19dWOkyvJpCu00vTp0xk0aJAUbg5r1KgR5cqVY9WqVWpHybVk0hVa4+TJk1y5coXWrVvj6upKREQEFhYWasfKd86dO0eXLl2IjIykTZs2bNq0CXNzc7Vj5Rqyt1tojfDwcIKCgrh48SI//PCDFK4KUlNTqVatGlWqVMHHx4eIiAgSExOldP+L7F4QWkOj0ZCYmMiePXuoWrUqdnZ2PH/+XO1Y+crhw4dxcnLC3d2dmTNnUqBAATQajdqxchWZdIXWSE9P59KlS1SoUIFhw4axZs0azMzM1I6Vr3z11VfMmzePQYMGYWVlxaNHj6R0/4dMukJr3L17l1u3bmFoaEhQUJA8dFIlHTp04OLFixgYGBAfH8/Lly/VjpSrSOkKreHi4sKQIUPYv38/1tbWasfJ17744gsuXLjA8OHDKV++vNpxchU5e0EIIXKQ7NMVuZ6iKMTFxXHz5s2/PTBWqFAhypUrh42NjdxsJRfRaDTExcXx+PFjnjx5Qlpa2ns/t0iRIhQrVoyiRYtiZGSUgylznpSuyJUeP36Mh4cHp06d4vbt2+jr62Nra4upqelf7tn66tUr7t+/z4sXL/jiiy+oWrUqnp6eVKhQQaX0+VNSUhILFizg6NGjXLlyhfj4eMzMzLC0tMTc3Py9V6gpisKLFy+Ij48nLi4OfX19ypUrR7169fj222+pXr16Dn8l2Ut2L4hcR6PR4Orqir29Pe3ataNkyZIULlz4g69LTk7m/v37nDt3jrVr1xIaGoqVlVUOJBYAPXv25P79+7Rr1w5nZ2csLS0zfeMbRVFISkri9u3bXLp0ifXr13Pt2jVKlCiRTalznpSuyHWuX79OmzZt2LJlyyc/iWD8+PH06tWLPn36ZHE68XfevHmDqakphw4dytLdA56enrRu3ZrBgwdn2TrVJjvARK4TFhaGvb39Zz36pXz58oSGhmZhKvFPIiMjsbGxyfL9sdr4PkrpilwnNDSUUqVKfdY6ypQpQ0hISBYlEh8SFhZG2bJls3y92vg+SumKXCc8PDxLSjciIiKLEokPiYiI4Isvvsjy9ZYpU4bIyMgsX6+a5OwFkeukpKRgaGiY8fcHDx4wfPhwXFxcuHr1KtbW1sydO5eYmBhmzpxJcnIytra2TJ48GVNTUwAMDQ1JSUlR60vId5KTkzEwMMj4+9KlSylSpAjdu3cHYPHixVhaWvLmzRsCAgJ48+YNTZo04bvvvuP169eMGzeO2NhYNBoNAwcOpEWLFoB2vo8y6Yo84e7du3zzzTds3LiRwoULc+TIETw8PBg2bBj+/v7Y2dnh4+Ojdkzxfzp06MDu3buBt/fEOHjwIBYWFty9e5fVq1fj5+dHWFgYly9f5syZM1hbW7N+/Xo2btxI3bp1VU6fvaR0RZ5gY2ODo6MjAE5OTty7d4/ExERq1KgBQNu2bbl8+bKaEcV/sbGxwczMjBs3bnDu3DkcHR0JDQ3l3Llz9OzZk169enH79m3u3LmDnZ0dFy5cYMGCBQQFBWFiYqJ2/GwluxdErvS/ZzL+94n1urq6JCYm5nQk8Q90dHT+8p517NiR3bt38/TpU9q3b09gYCD9+vXj66+//svr16xZw+nTp1m0aBG1a9fm22+/Bf76c6ANZNIVuY6VlRXx8fH/+DkmJiaYmpoSFBQEwJ49e965cikuLk4ujMhBVlZWJCQkvLOsSZMmnDlzhtDQUOrUqUOdOnXYuXMnr169AiA2Npb4+HiePHmCoaEhrVu3pnfv3ty4cSNjHU+fPsXS0jJHv5bsJpOuyHUqVqzIqVOnPvh5U6ZMyTiQVrJkSTw8PDI+dvv2bbkMOAc5OzuzZs2ad5bp6+tTs2ZNChcujK6uLrVr1yY6Opr+/fsDYGRkhJeXF3fv3mX+/PkUKFAAPT09xo0bl7GO6OhonJ2dc/RryW5SuiLXcXZ2Zu3atRl/t7GxYePGjRl/7927d8Z/v+8BiLdv36ZixYrZllG8y9nZmejo6HeWpaenc/36dWbNmpWxrHv37hlnNPyHra0tderU+dv1auP7KLsXRK5TuXJlIiIiPriL4X3S0tIIDAzUuhul5GY2Njbo6Ohk7Bq4desWnTp1olatWp98zrVGo9HK91HuvSBypSlTpuDt7U3dunWxsbHB1tb2vXcZe/nyJffv38/4c/nyZZydndm+fftnXUosMmfdunUMHTqUypUr4+joiLW1NRYWFlhYWGBubk7BggX/9nXp6ekkJiby9OlT4uPjefr0KXfu3CE4OBh7e3sOHjyoVbfslNIVuVZQUBBnz54lKiqKmzdvfvB+uuXLl8fOzo4qVarQtGlTKVwVxMbGcvr0aYKCgnj06BGPHj3KuJ9uamrqe19nbm6ecT/dEiVKYGdnR926dalUqZJWFS5I6QohRI7Srv+FCCFELielK4QQOUhKVwghctD/AwWL7TGZb/d5AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "myTree = retrieveTree(0)\n",
    "createPlot(myTree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}, 3: 'maybe'}}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myTree['no surfacing'][3] = 'maybe'\n",
    "myTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "createPlot(myTree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 测试分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "def classify(inputTree, featLabels, testVec):\n",
    "    firstStr = list(inputTree.keys())[0]  # 得到当前树的根节点\n",
    "    secondDict = inputTree[firstStr]  # 获取根节点下的子树集合\n",
    "    featIndex = featLabels.index(firstStr)  # 将标签转化为索引\n",
    "    for key in secondDict.keys():\n",
    "        if testVec[featIndex] == key:\n",
    "            if type(secondDict[key]).__name__ == 'dict':\n",
    "                classLabel = classify(secondDict[key], featLabels, testVec)\n",
    "            else:\n",
    "                classLabel = secondDict[key]\n",
    "    return classLabel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['no surfacing', 'flippers']"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myDat, labels = createDataSet()\n",
    "labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myTree = retrieveTree(0)\n",
    "myTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'no'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classify(myTree, labels, [1, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'yes'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classify(myTree, labels, [1, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 树的存储"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def storeTree(inputTree, filename):\n",
    "    import pickle\n",
    "    fw = open(filename, 'wb')\n",
    "    pickle.dump(inputTree, fw)\n",
    "    fw.close()\n",
    "\n",
    "def grabTree(filename):\n",
    "    import pickle\n",
    "    fr = open(filename, 'rb')\n",
    "    return pickle.load(fr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "storeTree(myTree, 'classifierStorage.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grabTree('classifierStorage.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 示例：使用决策树预测隐形眼镜类型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['young', 'myope', 'no', 'reduced', 'no lenses'],\n",
       " ['young', 'myope', 'no', 'normal', 'soft'],\n",
       " ['young', 'myope', 'yes', 'reduced', 'no lenses'],\n",
       " ['young', 'myope', 'yes', 'normal', 'hard'],\n",
       " ['young', 'hyper', 'no', 'reduced', 'no lenses'],\n",
       " ['young', 'hyper', 'no', 'normal', 'soft'],\n",
       " ['young', 'hyper', 'yes', 'reduced', 'no lenses'],\n",
       " ['young', 'hyper', 'yes', 'normal', 'hard'],\n",
       " ['pre', 'myope', 'no', 'reduced', 'no lenses'],\n",
       " ['pre', 'myope', 'no', 'normal', 'soft'],\n",
       " ['pre', 'myope', 'yes', 'reduced', 'no lenses'],\n",
       " ['pre', 'myope', 'yes', 'normal', 'hard'],\n",
       " ['pre', 'hyper', 'no', 'reduced', 'no lenses'],\n",
       " ['pre', 'hyper', 'no', 'normal', 'soft'],\n",
       " ['pre', 'hyper', 'yes', 'reduced', 'no lenses'],\n",
       " ['pre', 'hyper', 'yes', 'normal', 'no lenses'],\n",
       " ['presbyopic', 'myope', 'no', 'reduced', 'no lenses'],\n",
       " ['presbyopic', 'myope', 'no', 'normal', 'no lenses'],\n",
       " ['presbyopic', 'myope', 'yes', 'reduced', 'no lenses'],\n",
       " ['presbyopic', 'myope', 'yes', 'normal', 'hard'],\n",
       " ['presbyopic', 'hyper', 'no', 'reduced', 'no lenses'],\n",
       " ['presbyopic', 'hyper', 'no', 'normal', 'soft'],\n",
       " ['presbyopic', 'hyper', 'yes', 'reduced', 'no lenses'],\n",
       " ['presbyopic', 'hyper', 'yes', 'normal', 'no lenses']]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fr = open('lenses.txt')\n",
    "lenses = [inst.strip().split('\\t') for inst in fr.readlines()]\n",
    "lenses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'tearRate': {'reduced': 'no lenses',\n",
       "  'normal': {'astigmatic': {'yes': {'prescript': {'hyper': {'age': {'pre': 'no lenses',\n",
       "        'young': 'hard',\n",
       "        'presbyopic': 'no lenses'}},\n",
       "      'myope': 'hard'}},\n",
       "    'no': {'age': {'pre': 'soft',\n",
       "      'young': 'soft',\n",
       "      'presbyopic': {'prescript': {'hyper': 'soft',\n",
       "        'myope': 'no lenses'}}}}}}}}"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']\n",
    "lensesTree = createTree(lenses, lensesLabels)\n",
    "lensesTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "createPlot(lensesTree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
